package com.lh.utils;

import com.lh.entity.table.DeadlineNode;
import com.lh.entity.table.RectificationInfo;
import com.lh.entity.table.RectificationInfoApproval;
import com.lh.entity.table.TreeNode;
import com.lh.entity.vo.RectificationV2Vo;
import org.springframework.beans.BeanUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class RectificationClassifier {

    /**
     * 修正版三级分类树生成方法
     * 确保所有存在的类别（包括层级不完整的）都能正确显示
     */
    public static List<TreeNode> classifyThreeLevels(List<RectificationInfo> rectificationInfoList) {
        // 根节点列表，即一级分类
        List<TreeNode> rootNodes = new ArrayList<>();

        if (rectificationInfoList == null || rectificationInfoList.isEmpty()) {
            return rootNodes;
        }

        for (RectificationInfo info : rectificationInfoList) {
            // 获取三级分类的值，允许部分为null
            String level1 = info.getProjectType();       // 一级分类
            String level2 = info.getProjectChildType();  // 二级分类
            String level3 = info.getProjectChildCategoryType();  // 三级分类

            // 至少需要有一级分类才能继续
            if (level1 == null) {
                continue;
            }

            // 查找或创建一级节点
            TreeNode level1Node = findOrCreateNode(rootNodes, level1, 1);
            level1Node.incrementCount();

            // 处理二级节点（允许为null，但不为null时才创建）
            if (level2 != null) {
                TreeNode level2Node = findOrCreateNode(level1Node.getChildren(), level2, 2);
                level2Node.incrementCount();

                // 处理三级节点（允许为null，但不为null时才创建）
                if (level3 != null) {
                    TreeNode level3Node = findOrCreateNode(level2Node.getChildren(), level3, 3);
                    level3Node.incrementCount();
                }
            }
        }

        return rootNodes;
    }

    public static List<TreeNode> classifyThreeLevels(List<RectificationInfoApproval> rectificationInfoList,String rectificationInfoApproval) {
        // 根节点列表，即一级分类
        List<TreeNode> rootNodes = new ArrayList<>();

        if (rectificationInfoList == null || rectificationInfoList.isEmpty()) {
            return rootNodes;
        }

        for (RectificationInfoApproval info : rectificationInfoList) {
            // 获取三级分类的值，允许部分为null
            String level1 = info.getProjectType();       // 一级分类
            String level2 = info.getProjectChildType();  // 二级分类
            String level3 = info.getProjectChildCategoryType();  // 三级分类

            // 至少需要有一级分类才能继续
            if (level1 == null) {
                continue;
            }

            // 查找或创建一级节点
            TreeNode level1Node = findOrCreateNode(rootNodes, level1, 1);
            level1Node.incrementCount();

            // 处理二级节点（允许为null，但不为null时才创建）
            if (level2 != null) {
                TreeNode level2Node = findOrCreateNode(level1Node.getChildren(), level2, 2);
                level2Node.incrementCount();

                // 处理三级节点（允许为null，但不为null时才创建）
                if (level3 != null) {
                    TreeNode level3Node = findOrCreateNode(level2Node.getChildren(), level3, 3);
                    level3Node.incrementCount();
                }
            }
        }

        return rootNodes;
    }

    /**
     * 在节点列表中查找指定key的节点，如果不存在则创建新节点
     */
    private static TreeNode findOrCreateNode(List<TreeNode> nodes, String key, int level) {
        // 先尝试查找已存在的节点
        for (TreeNode node : nodes) {
            if (key.equals(node.getKey())) {
                return node;
            }
        }

        // 创建新节点并添加到列表
        TreeNode newNode = new TreeNode(key, key, level);
        nodes.add(newNode);
        return newNode;
    }




    // 区划列表
    private static final List<String> DISTRICTS = Arrays.asList(
            "黄州区", "团风县", "红安县", "麻城市",
            "罗田县", "英山县", "浠水县", "蕲春县",
            "武穴市", "黄梅县", "黄冈高新区","市临空经济区",
            "龙感湖管理区", "白莲河示范区"
    );

    // 市直部门列表
    public static final List<String> DEPARTMENTS = Arrays.asList(
            "市纪委监委机关", "市委组织部", "市委社工部", "市委政法委",
            "市发改委", "市招商服务中心", "市交通运输局", "市资建局",
            "市城管执法委", "市生态环境局", "市水利和湖泊局", "市林业局",
            "市住新局", "市公安局", "市信访局", "市政数局",
            "市应急管理局", "黄冈国投集团", "市经信局", "市教育局", "市科技局",
            "市民政局", "市司法局", "市财政局", "市人力资源和社会保障局", "市农业农村局",
            "市商务局", "市文旅局", "市卫健委", "市政府国资委", "市市场监督局",
            "市机关事务中心", "市公共资源交易中心", "市公共检验检测中心", "市供销社",
            "市体育发展中心", "市国资委", "市城管委"
    );
    //市生态环境局、市水利和湖泊局

    // 合并所有部门并按长度倒序排序（确保长名称优先匹配）
    private static final List<String> ALL_ORGANIZATIONS;
    static {
        ALL_ORGANIZATIONS = new ArrayList<>();
        ALL_ORGANIZATIONS.addAll(DISTRICTS);
        ALL_ORGANIZATIONS.addAll(DEPARTMENTS);
        // 按名称长度倒序排序，避免短名称提前匹配
        ALL_ORGANIZATIONS.sort((a, b) -> Integer.compare(b.length(), a.length()));
    }

    /**
     * 处理整改信息列表，拆分部门名称并过滤出市直部门，返回新的RectificationInfo列表
     * @param originalList 原始整改信息列表
     * @return 处理后的RectificationInfo列表
     */
    public static List<RectificationInfo> process(List<RectificationInfo> originalList) {
        List<RectificationInfo> resultList = new ArrayList<>();

        if (originalList == null || originalList.isEmpty()) {
            return resultList;
        }

        for (RectificationInfo original : originalList) {
            String deptName = original.getDepartmentName();
            if (deptName == null || deptName.trim().isEmpty()) {
                continue;
            }

            // 拆分部门名称
            List<String> splitDepartments = splitDepartmentName(deptName);

            // 过滤出市直部门（排除区划）并处理
            List<String> filteredDepartments = splitDepartments.stream()
                    .filter(dept -> !DISTRICTS.contains(dept) && DEPARTMENTS.contains(dept))
                    .collect(Collectors.toList());

            // 为每个拆分后的市直部门创建新的RectificationInfo对象
            for (String dept : filteredDepartments) {
                RectificationInfo newInfo = createNewRectificationInfo(original, dept);
                resultList.add(newInfo);
            }
        }

        return resultList;
    }


    /**
     * 处理整改信息列表，拆分部门名称并过滤出市直部门，返回新的RectificationInfo列表
     * @param originalList 原始整改信息列表
     * @return 处理后的RectificationInfo列表
     */
    public static List<RectificationInfo> processArea(List<RectificationInfo> originalList) {
        List<RectificationInfo> resultList = new ArrayList<>();

        if (originalList == null || originalList.isEmpty()) {
            return resultList;
        }

        for (RectificationInfo original : originalList) {
            String deptName = original.getDepartmentName();
            if (deptName == null || deptName.trim().isEmpty()) {
                continue;
            }

            // 拆分部门名称
            List<String> splitDepartments = splitDepartmentName(deptName);

            // 过滤出县市区（只保留区划，排除市直部门）并处理
            List<String> filteredDepartments = splitDepartments.stream()
                    .filter(dept -> DISTRICTS.contains(dept) && !DEPARTMENTS.contains(dept))
                    .collect(Collectors.toList());

            // 为每个拆分后的县市区创建新的RectificationInfo对象
            for (String dept : filteredDepartments) {
                RectificationInfo newInfo = createNewRectificationInfo(original, dept);
                resultList.add(newInfo);
            }
        }

        return resultList;
    }


    /**
     * 处理整改信息列表，拆分部门名称并过滤出市直部门，返回新的RectificationInfo列表
     * @param originalList 原始整改信息列表
     * @return 处理后的RectificationInfo列表
     */
    public static List<RectificationInfo> SplitPerson(List<RectificationInfo> originalList) {
        List<RectificationInfo> resultList = new ArrayList<>();
        String PERSON_SEPARATORS_REGEX = "[,，/、\\s]+";

        if (originalList == null || originalList.isEmpty()) {
            return resultList;
        }

        for (RectificationInfo original : originalList) {
            String personLiaible = original.getPersonLiaible();
            if (personLiaible == null || personLiaible.trim().isEmpty()) {
                // 如果负责人为空，可选择直接添加原对象或跳过
                resultList.add(original);
                continue;
            }
            // 按照分隔符拆分负责人
            String[] persons = personLiaible.split(PERSON_SEPARATORS_REGEX);
            // 为每个拆分后的负责人创建新的RectificationInfo对象
            for (String person : persons) {
                // 去除前后空格
                String trimmedPerson = person.trim();
                if (!trimmedPerson.isEmpty()) {
                    RectificationInfo newInfo = createNewRectificationInfoPerson(original, trimmedPerson);
                    resultList.add(newInfo);
                }
            }
        }
        return resultList;
    }


    /**
     * 处理整改信息列表，拆分部门名称并过滤出市直部门，返回新的RectificationInfo列表
     * @param originalList 原始整改信息列表
     * @return 处理后的RectificationInfo列表
     */
    public static List<RectificationInfo> SplitDepartment(List<RectificationInfo> originalList) {
        List<RectificationInfo> resultList = new ArrayList<>();
        String PERSON_SEPARATORS_REGEX = "[,，/、\\s]+";

        if (originalList == null || originalList.isEmpty()) {
            return resultList;
        }
        for (RectificationInfo original : originalList) {
            String departmentName = original.getDepartmentName();
            if (departmentName == null || departmentName.trim().isEmpty()) {
                // 如果负责人为空，可选择直接添加原对象或跳过
                resultList.add(original);
                continue;
            }
            // 按照分隔符拆分负责人
            String[] departList = departmentName.split(PERSON_SEPARATORS_REGEX);
            // 为每个拆分后的负责人创建新的RectificationInfo对象
            for (String department : departList) {
                // 去除前后空格
                String trimmedDepartment = department.trim();
                if (!trimmedDepartment.isEmpty()) {
                    RectificationInfo newInfo = createNewRectificationInfoDepart(original, trimmedDepartment);
                    resultList.add(newInfo);
                }
            }
        }
        return resultList;
    }


    /**
     * 环节处理责任人，拆分部门名称并过滤出市直部门，返回新的RectificationInfo列表
     * @param originalList 原始整改信息列表
     * @return 处理后的RectificationInfo列表
     */
    public static List<DeadlineNode> SplitNodePerson(List<DeadlineNode> originalList) {
        List<DeadlineNode> resultList = new ArrayList<>();
        String PERSON_SEPARATORS_REGEX = "[,，/、\\s]+";

        if (originalList == null || originalList.isEmpty()) {
            return resultList;
        }

        for (DeadlineNode original : originalList) {
            String personLiaible = original.getDescription();
            if (personLiaible == null || personLiaible.trim().isEmpty()) {
                // 如果负责人为空，可选择直接添加原对象或跳过
                continue;
            }
            // 按照分隔符拆分负责人
            String[] persons = personLiaible.split(PERSON_SEPARATORS_REGEX);
            // 为每个拆分后的负责人创建新的RectificationInfo对象
            for (String person : persons) {
                // 去除前后空格
                String trimmedPerson = person.trim();
                if (!trimmedPerson.isEmpty()) {
                    DeadlineNode newInfo = createNewDeadLineNodePerson(original, trimmedPerson);
                    resultList.add(newInfo);
                }
            }
        }
        return resultList;
    }


    /**
     * 拆分组合的部门名称
     * @param fullDeptName 组合的部门名称字符串
     * @return 拆分后的部门名称列表
     */
    private static List<String> splitDepartmentName(String fullDeptName) {
        List<String> result = new ArrayList<>();
        if (fullDeptName == null || fullDeptName.trim().isEmpty()) {
            return result;
        }

        // 定义可能的分隔符（根据实际数据扩展）
        String[] separators = {"、", "，", ",", "；", ";", " ", "和", "与"};
        String remaining = fullDeptName.trim();

        while (!remaining.isEmpty()) {
            boolean found = false;
            // 尝试匹配部门
            for (String org : ALL_ORGANIZATIONS) {
                if (remaining.startsWith(org)) {
                    result.add(org);
                    // 匹配成功后，截取剩余字符串并 trim
                    remaining = remaining.substring(org.length()).trim();
                    found = true;
                    break;
                }
            }
            if (found) {
                continue; // 继续匹配下一个部门
            }

            // 未匹配到部门，检查是否是分隔符，若是则跳过
            boolean isSeparator = false;
            for (String sep : separators) {
                if (remaining.startsWith(sep)) {
                    // 跳过分隔符
                    remaining = remaining.substring(sep.length()).trim();
                    isSeparator = true;
                    break;
                }
            }
            if (isSeparator) {
                continue; // 跳过分隔符后继续匹配
            }

            // 既不是部门也不是分隔符，避免死循环，退出
            break;
        }

        return result;
    }

    /**
     * 复制原始RectificationInfo的属性，创建新对象并设置拆分后的部门名称
     * @param original 原始整改信息
     * @param deptName 拆分后的部门名称
     * @return 新的RectificationInfo对象
     */
    private static RectificationInfo createNewRectificationInfo(RectificationInfo original, String deptName) {
        RectificationInfo newInfo = new RectificationInfo();
        // 复制原有属性
        BeanUtils.copyProperties(original, newInfo);
        // 设置拆分后的部门名称
        newInfo.setDepartmentName(deptName);
        // 可以在这里添加其他需要的处理逻辑
        return newInfo;
    }


    /**
     * 复制原始RectificationInfo的属性，创建新对象并设置拆分后的部门名称
     * @param original 原始整改信息
     * @param person 拆分后的部门名称
     * @return 新的RectificationInfo对象
     */
    private static RectificationInfo createNewRectificationInfoPerson(RectificationInfo original, String person) {
        RectificationInfo newInfo = new RectificationInfo();
        // 复制原有属性
        BeanUtils.copyProperties(original, newInfo);
        // 设置拆分后的部门名称
        newInfo.setPersonLiaible(person);
        // 可以在这里添加其他需要的处理逻辑
        return newInfo;
    }


    private static RectificationInfo createNewRectificationInfoDepart(RectificationInfo original, String department) {
        RectificationInfo newInfo = new RectificationInfo();
        // 复制原有属性
        BeanUtils.copyProperties(original, newInfo);
        // 设置拆分后的部门名称
        newInfo.setDepartmentName(department);
        // 可以在这里添加其他需要的处理逻辑
        return newInfo;
    }



    private static DeadlineNode createNewDeadLineNodePerson(DeadlineNode original, String person) {
        DeadlineNode newInfo = new DeadlineNode();
        // 复制原有属性
        BeanUtils.copyProperties(original, newInfo);
        // 设置拆分后的部门名称
        newInfo.setDescription(person);
        // 可以在这里添加其他需要的处理逻辑
        return newInfo;
    }

    /**
     * 将处理后的RectificationInfo列表按部门合并，转换为RectificationV2Vo列表
     * @param processedList 处理后的RectificationInfo列表
     * @return 合并后的RectificationV2Vo列表
     */
    public static List<RectificationV2Vo> mergeByDepartment(List<RectificationInfo> processedList) {
        if (processedList == null || processedList.isEmpty()) {
            return new ArrayList<>();
        }

        // 按部门名称分组
        Map<String, List<RectificationInfo>> departmentGroups = processedList.stream()
                .collect(Collectors.groupingBy(RectificationInfo::getDepartmentName));

        List<RectificationV2Vo> resultList = new ArrayList<>();

        // 处理每个部门的分组数据
        for (Map.Entry<String, List<RectificationInfo>> entry : departmentGroups.entrySet()) {
            String departmentName = entry.getKey();
            List<RectificationInfo> infoList = entry.getValue();

            // 初始化统计数据
            int green = 0;
            int yellow = 0;
            int red = 0;

            // 统计各警告级别的数量
            for (RectificationInfo info : infoList) {
                Integer warnLevel = info.getWarnLevel(); // 假设存在此方法获取警告级别
                if (warnLevel == null) {
                    continue;
                }

                switch (warnLevel) {
                    case 0:
                        green++;
                        break;
                    case 1:
                        yellow++;
                        break;
                    case 2:
                        red++;
                        break;
                    default:
                        // 忽略未知的警告级别
                        break;
                }
            }

            // 计算总数和绿灯率
            int total = green + yellow + red;
            String totalGreenRate = calculateRate(green, total);
            String rate = calculateRate(red, total);
            // 创建并设置V2Vo对象
            RectificationV2Vo vo = new RectificationV2Vo();
            vo.setStreet(departmentName); // departmentName对应street字段
            vo.setGreen(green);
            vo.setYellow(yellow);
            vo.setRed(red);
            vo.setTotal(total);
            vo.setTotalGreenRate(totalGreenRate);
            vo.setRate(rate);
            resultList.add(vo);
        }

        return resultList;
    }

    /**
     * 计算比率（保留两位小数的百分比格式）
     * @param numerator 分子（如绿灯数量）
     * @param denominator 分母（如总数）
     * @return 格式化的比率字符串
     */
    private static String calculateRate(int numerator, int denominator) {
        if (denominator == 0) {
            return "0.0%";
        }
        double rate = (double) numerator / denominator * 100;
        return String.format("%.1f%%", rate);
    }


}
